Операции JavaScript BigInt: Математические вычисления с большими числами

JavaScript исторически испытывал трудности с точным представлением очень больших целых чисел из-за того, что его тип Number является двоичным форматом с двойной точностью (IEEE 754). Это ограничение становится проблематичным в сценариях, требующих точности, выходящей за рамки того, что может предложить Number, таких как криптография, финансовые расчеты или научное моделирование. Представляем BigInt, новый примитивный тип данных в JavaScript, предназначенный для представления целых чисел произвольной длины.

Что такое BigInt?

BigInt — это встроенный объект, который предоставляет способ представления целых чисел, превышающих 2⁵³ - 1, что является максимальным безопасным целым числом, которое тип Number в JavaScript может точно представлять. Без BigInt выполнение вычислений с числами, превышающими этот предел, может привести к потере точности и неверным результатам. BigInt решает эту проблему, позволяя вам работать с произвольно большими целыми числами без потери точности.

Создание BigInts

Вы можете создать BigInt двумя способами:

• Добавив n в конец целочисленного литерала.
• Вызвав конструктор BigInt().

Вот несколько примеров:

const bigIntLiteral = 123456789012345678901234567890n;
const bigIntConstructor = BigInt(123456789012345678901234567890);
const bigIntFromString = BigInt("123456789012345678901234567890");

console.log(bigIntLiteral); // Вывод: 123456789012345678901234567890n
console.log(bigIntConstructor); // Вывод: 123456789012345678901234567890n
console.log(bigIntFromString); // Вывод: 123456789012345678901234567890n

Обратите внимание, что вы можете создать BigInt из числа, строки, представляющей число, или непосредственно как литерал BigInt. Попытка создать BigInt из числа с плавающей запятой приведет к RangeError.

Основные операции BigInt

BigInt поддерживает большинство стандартных арифметических операторов, включая сложение, вычитание, умножение, деление и модуль.

Арифметические операторы

Вот как использовать основные арифметические операторы с BigInt:

const a = 10n;
const b = 5n;

console.log(a + b); // Вывод: 15n (Сложение)
console.log(a - b); // Вывод: 5n (Вычитание)
console.log(a * b); // Вывод: 50n (Умножение)
console.log(a / b); // Вывод: 2n (Деление - усекает в сторону нуля)
console.log(a % b); // Вывод: 0n (Модуль)
console.log(a ** b); // Вывод: 100000n (Возведение в степень)

Важное примечание: Вы не можете смешивать BigInts с Numbers в арифметических операциях. Это приведет к TypeError. Вы должны явно преобразовать Number в BigInt перед выполнением операции.

const bigInt = 10n;
const number = 5;

// console.log(bigInt + number); // Вызывает TypeError
console.log(bigInt + BigInt(number)); // Вывод: 15n (Правильно)

Операторы сравнения

BigInts можно сравнивать с помощью стандартных операторов сравнения:

const a = 10n;
const b = 5n;

console.log(a > b); // Вывод: true
console.log(a < b); // Вывод: false
console.log(a >= b); // Вывод: true
console.log(a <= b); // Вывод: false
console.log(a === b); // Вывод: false
console.log(a !== b); // Вывод: true

console.log(a == BigInt(10)); // Вывод: true
console.log(a === BigInt(10)); // Вывод: true

console.log(a == 10); // Вывод: true
console.log(a === 10); // Вывод: false

Хотя вы можете использовать нестрогое равенство (==) для сравнения BigInt с Number, обычно рекомендуется использовать строгое равенство (===) и явно преобразовывать Number в BigInt для ясности и во избежание неожиданного приведения типов.

Битовые операторы

BigInts также поддерживают битовые операторы:

const a = 10n; // 1010 в двоичном виде
const b = 3n;  // 0011 в двоичном виде

console.log(a & b); // Вывод: 2n (Битовое И)
console.log(a | b); // Вывод: 11n (Битовое ИЛИ)
console.log(a ^ b); // Вывод: 9n (Битовое XOR)
console.log(~a);  // Вывод: -11n (Битовое НЕ - двоичное дополнение)
console.log(a << b); // Вывод: 80n (Сдвиг влево)
console.log(a >> b); // Вывод: 1n (Сдвиг вправо)
console.log(a >>> b); // Вызывает TypeError (Беззнаковый сдвиг вправо не поддерживается для BigInt)

Обратите внимание, что оператор беззнакового сдвига вправо (>>>) не поддерживается для BigInts, поскольку BigInts всегда являются знаковыми.

Продвинутые техники BigInt

Работа с библиотеками

Хотя BigInt предоставляет основные строительные блоки для арифметики больших чисел, использование специализированных библиотек может значительно повысить производительность и предоставить дополнительные функциональные возможности для более сложных операций. Вот несколько примечательных библиотек:

• jsbn: Быстрая, переносимая реализация математики больших чисел на чистом JavaScript.
• BigInteger.js: Еще одна популярная библиотека, предлагающая полный набор арифметических и битовых операций над целыми числами произвольной длины.
• elliptic: Специально разработана для криптографии на эллиптических кривых, которая в значительной степени полагается на арифметику BigInt.

Эти библиотеки часто предоставляют оптимизированные алгоритмы и специализированные функции, которые могут быть решающими для приложений, чувствительных к производительности.

Соображения производительности

Хотя BigInt обеспечивает произвольную точность, важно помнить о его влиянии на производительность. Операции BigInt обычно выполняются медленнее, чем операции Number, поскольку они требуют больше памяти и вычислительных ресурсов. Поэтому крайне важно использовать BigInt только при необходимости и оптимизировать свой код для повышения производительности.

Вот несколько советов по оптимизации производительности BigInt:

• Избегайте ненужных преобразований: Сведите к минимуму количество преобразований между Numbers и BigInts.
• Используйте эффективные алгоритмы: Выбирайте алгоритмы, оптимизированные для арифметики больших чисел. Библиотеки, такие как jsbn и BigInteger.js, часто предоставляют высокооптимизированные реализации.
• Профилируйте свой код: Используйте инструменты профилирования JavaScript для выявления узких мест производительности и соответствующей оптимизации своего кода.

Безопасность типов

TypeScript обеспечивает отличную поддержку BigInt, позволяя вам обеспечивать безопасность типов и предотвращать ошибки, связанные со смешиванием BigInts с Numbers. Вы можете явно объявить переменные как BigInt, чтобы гарантировать, что они будут содержать только значения BigInt.

let bigIntValue: bigint = 12345678901234567890n;

// bigIntValue = 5; // TypeScript выдаст ошибку, потому что вы пытаетесь присвоить число bigint.

console.log(bigIntValue);

function addBigInts(a: bigint, b: bigint): bigint {
  return a + b;
}

console.log(addBigInts(10n, 20n)); // Вывод: 30n
// console.log(addBigInts(10, 20)); // TypeScript выдаст ошибку

Используя систему типов TypeScript, вы можете выявлять потенциальные ошибки на ранних этапах разработки и повышать надежность своего кода.

Реальные применения BigInt

BigInts необходимы в различных областях, где важна точная обработка больших целых чисел. Давайте рассмотрим некоторые известные приложения:

Криптография

Криптография в значительной степени полагается на большие простые числа и сложные математические операции, требующие произвольной точности. BigInts незаменимы для реализации криптографических алгоритмов, таких как RSA, ECC (криптография на эллиптических кривых) и обмен ключами Диффи-Хеллмана.

Пример: RSA шифрование

RSA включает в себя генерацию больших простых чисел и выполнение модульного возведения в степень с большими целыми числами. BigInts используются для представления этих простых чисел и для выполнения необходимых вычислений без потери точности. Безопасность RSA зависит от сложности факторизации больших чисел, что делает BigInts решающими для его реализации.

Финансовые расчеты

Финансовые расчеты часто связаны с обработкой больших сумм денег или выполнением сложных вычислений с высокой точностью. BigInts можно использовать для точного представления денежных значений и избежания ошибок округления, которые могут возникнуть при использовании чисел с плавающей запятой. Это особенно важно в таких приложениях, как системы бухгалтерского учета, банковское программное обеспечение и финансовое моделирование.

Пример: Расчет процентов по крупному кредиту

При расчете процентов по крупному кредиту даже небольшие ошибки округления могут накапливаться с течением времени и приводить к значительным расхождениям. Использование BigInts для представления основной суммы, процентной ставки и других соответствующих значений гарантирует, что расчеты будут точными и надежными.

Научные вычисления

Научные моделирования и расчеты часто связаны с обработкой чрезвычайно больших или малых чисел. BigInts можно использовать для точного представления этих чисел и выполнения необходимых вычислений без потери точности. Это особенно важно в таких областях, как астрономия, физика и химия, где точность имеет первостепенное значение.

Пример: Расчет количества атомов в моле

Число Авогадро (приблизительно 6,022 x 10²³) представляет собой количество атомов в моле вещества. Это число намного превышает безопасный предел целых чисел для типа Number в JavaScript. Использование BigInts позволяет точно представить число Авогадро и выполнять вычисления с его использованием без потери точности.

Высокоточные временные метки

В распределенных системах или высокочастотных торговых приложениях точные временные метки необходимы для поддержания согласованности данных и правильной сортировки событий. BigInts можно использовать для представления временных меток с наносекундной или даже пикосекундной точностью, гарантируя точную сортировку событий даже в сценариях с чрезвычайно высокой частотой событий.

Технология блокчейн

Технология блокчейн в значительной степени полагается на криптографические операции и арифметику больших чисел. BigInts используются для представления идентификаторов транзакций, хешей блоков и других криптографических значений с высокой точностью. Они также используются в смарт-контрактах для выполнения сложных вычислений и обеспечения соблюдения финансовых правил без использования чисел с плавающей запятой.

Пример: Смарт-контракты Ethereum

Смарт-контракты Ethereum часто включают в себя сложные финансовые расчеты и управление цифровыми активами. Использование BigInts гарантирует, что эти расчеты будут выполняться точно и что значения активов будут представлены без ошибок округления.

Совместимость с браузерами

BigInt имеет отличную поддержку браузеров в современных браузерах, включая Chrome, Firefox, Safari и Edge. Однако важно учитывать совместимость с браузерами при разработке приложений, которые должны поддерживать старые браузеры. Вы можете использовать полифилы или транспиляторы, такие как Babel, для обеспечения поддержки BigInt для старых браузеров. Многие старые браузеры не имеют встроенной поддержки BigInt, но полифилы доступны для добавления функциональности. Проверьте веб-сайт CanIUse для получения обновленной диаграммы.

Например, Babel может транспилировать ваш код, использующий BigInt, в эквивалентный код, который работает даже в старых движках Javascript.

Преобразование в другие типы и из них

Преобразование между BigInt и другими типами JavaScript требует явного преобразования. Вот правила:

• В Number: Используйте Number(bigIntValue). Будьте осторожны, так как это может привести к потере точности, если BigInt слишком велик.
• В String: Используйте String(bigIntValue). Это, как правило, безопасно и обеспечивает строковое представление BigInt.
• Из Number: Используйте BigInt(numberValue). Это рекомендуется только для целых чисел. Числа с плавающей запятой, переданные конструктору BigInt, вызовут RangeError.
• Из String: Используйте BigInt(stringValue). Строка должна представлять целое число, иначе произойдет ошибка SyntaxError.

let bigIntVal = 123456789012345678901234567890n;
let numVal = Number(bigIntVal); // Потенциально потеря точности
let strVal = String(bigIntVal); // Безопасное преобразование в строку

console.log(numVal); // Показывает потерю точности.
console.log(strVal);

let newBigInt = BigInt(100); // Создает из целого числа Number

console.log(newBigInt);

let newBigIntFromString = BigInt("98765432109876543210"); // из строки

console.log(newBigIntFromString);

// BigInt(3.14); // вызовет ошибку диапазона

Ошибки и соображения

Хотя BigInts невероятно полезны, вы должны знать об определенных ошибках:

• Ошибки типов: Помните, что BigInts нельзя напрямую смешивать с Numbers в арифметических операциях.
• Производительность: Операции BigInt выполняются медленнее, чем стандартные операции Number.
• Потеря точности: Преобразование очень больших BigInts в Numbers может привести к потере точности из-за ограничений типа Number.
• Отсутствие поддержки стандартной библиотеки: Не все стандартные методы JavaScript напрямую совместимы с BigInts. Возможно, вам потребуется реализовать пользовательские функции или использовать библиотеки, которые явно поддерживают BigInts.
• Приоритет операторов: Помните о приоритете операторов при использовании битовых операторов с BigInts.

Заключение

BigInt — это мощное дополнение к JavaScript, которое позволяет разработчикам работать с произвольно большими целыми числами без потери точности. Эта возможность необходима в различных областях, включая криптографию, финансовые расчеты, научные вычисления и технологию блокчейн. Понимая основы операций BigInt, соображения производительности и реальные приложения, разработчики могут использовать этот тип данных для создания более надежных и надежных приложений, требующих точной обработки больших чисел. Хотя существуют некоторые соображения о производительности и типе, преимущества использования BigInt, когда это необходимо, значительны.

По мере того, как JavaScript продолжает развиваться, BigInt, несомненно, будет играть все более важную роль, позволяя разработчикам решать сложные проблемы, требующие арифметики с произвольной точностью. Мир все больше и больше полагается на вычисления, и точность имеет первостепенное значение.

Рассматривайте это всеобъемлющее руководство как отправную точку, углубитесь в библиотеки и изучите творческие способы применения BigInt к своим проектам.